package main

import (
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"

	"gopkg.in/yaml.v2"
)

// "github.com/ghodss/yaml"

type Deploy struct {
	App      string
	Name     string
	Replicas int
	Port     int
	SvcPort  int
}

var deployList []Deploy

func DeployParse(m map[interface{}]interface{}) {
	fmt.Println("~~~~~~~~~~~~~~~DeployParse func~~~~~~~~~~~~~~~~~~~~~~")
	for k, v := range m {
		if kk, ok := k.(string); ok {
			var deploy Deploy
			deploy.App = kk
			if vv, ok := v.(map[interface{}]interface{}); ok {
				for i, u := range vv {
					if ii, ok := i.(string); ok {
						switch uu := u.(type) {
						case string:
							if ii == "name" {
								deploy.Name = uu
							}
						case int:
							if ii == "replicas" {
								deploy.Replicas = uu
							} else if ii == "port" {
								deploy.Port = uu
							} else if ii == "svcPort" {
								deploy.SvcPort = uu
							}
						}
					}
				}
				deployList = append(deployList, deploy)
			}
		}
	}
}

// exec_mv 使用mv命令行工具对指定文件进行移动。
// src: 源文件名。
// dec: 目标文件名。
func exec_mv(src, dec string) {
	fmt.Println("~~~~~~~~~~~~~~~exec_mv func~~~~~~~~~~~~~~~~~~~~~~")
	fmt.Println(src, dec)
	cmd := exec.Command("C:/Program Files/Git/usr/bin/cp.exe", src, dec)
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		log.Fatalln(err)
	}
	defer stdout.Close()
	stderr, err := cmd.StderrPipe()
	if err != nil {
		log.Fatalln(err)
	}
	defer stderr.Close()
	if err := cmd.Start(); err != nil {
		log.Fatalf("Error starting command: %s", err)
	}

	// 读取输出
	outBytes, err := io.ReadAll(stdout)
	if err != nil {
		log.Fatalf("Error reading stdout: %s", err)
	}
	errBytes, err := io.ReadAll(stderr)
	if err != nil {
		log.Fatalf("Error reading stderr: %s", err)
	}
	fmt.Printf("stdout: %s\nstderr: %s\n", outBytes, errBytes)
	// 等待命令结束
	if err := cmd.Wait(); err != nil {
		log.Fatalf("Error waiting for command: %s", err)
	}
}

// 使用sed命令替换文件中的文本
// filePath: 文件路径。
// searchPattern: 要搜索的文本。
// replaceWith: 要替换的新文本。
func exec_sed(filePath, searchPattern, replaceWith string) error {
	fmt.Println("~~~~~~~~~~~~~~~exec_sed func~~~~~~~~~~~~~~~~~~~~~~")
	fmt.Println(filePath, searchPattern, replaceWith)

	// 构建sed命令，这里假设使用的是Linux环境下的sed路径
	sedCmd := []string{"C:/Program Files/Git/usr/bin/sed.exe", "-i", fmt.Sprintf("s/%s/%s/g", searchPattern, replaceWith), filePath}
	fmt.Println(sedCmd)
	// 使用exec.Command创建命令
	cmd := exec.Command(sedCmd[0], sedCmd[1:]...)

	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Fatalf("cmd.CombinedOutput() failed with '%s'\n", err)
	}
	fmt.Printf("Output: %s\n", output)

	// // 获取命令的输出和错误
	// var out bytes.Buffer
	// var stderr bytes.Buffer
	// cmd.Stdout = &out
	// cmd.Stderr = &stderr

	// // 执行命令
	// err := cmd.Run()
	// if err != nil {
	// 	return fmt.Errorf("executing sed command failed: %w, stdout: %s, stderr: %s", err, out.String(), stderr.String())
	// }

	// stdout, err := cmd.StdoutPipe()
	// if err != nil {
	// 	log.Fatalln(err)
	// }
	// defer stdout.Close()
	// stderr, err := cmd.StderrPipe()
	// if err != nil {
	// 	log.Fatalln(err)
	// }
	// defer stderr.Close()
	// if err := cmd.Start(); err != nil {
	// 	log.Fatalf("Error starting command: %s", err)
	// }

	// // 读取输出
	// outBytes, err := io.ReadAll(stdout)
	// if err != nil {
	// 	log.Fatalf("Error reading stdout: %s", err)
	// }
	// errBytes, err := io.ReadAll(stderr)
	// if err != nil {
	// 	log.Fatalf("Error reading stderr: %s", err)
	// }
	// fmt.Printf("stdout: %s\nstderr: %s\n", outBytes, errBytes)
	// // 等待命令结束
	// if err := cmd.Wait(); err != nil {
	// 	log.Fatalf("Error waiting for command: %s", err)
	// }

	return nil
}

func main() {
	content, err := os.ReadFile("./yaml/values.yaml")
	if err != nil {
		log.Fatalln(err)
	}
	// fmt.Println("~~~~~~~~~~~~~~read yaml file~~~~~~~~~~~~~~~~~~~~~~~")
	// fmt.Printf("content type is %T\n", content)
	// fmt.Println(content)

	t := map[string]interface{}{}
	err = yaml.Unmarshal(content, &t)
	if err != nil {
		log.Fatalln(err)
	}
	// fmt.Println("~~~~~~~~~~~yaml file to json~~~~~~~~~~~~~~~~~~~~~~~~~~")
	// fmt.Println(t)

	// 解析json
	fmt.Println("~~~~~~~~~~~~~~parse json~~~~~~~~~~~~~~~~~~~~~~~")
	for k, v := range t {
		switch value := v.(type) {
		case string:
			fmt.Printf("key: %s, value type is %T, value: %v\n", k, value, value)
		case int:
			fmt.Printf("key: %s, value type is %T, value: %v\n", k, value, value)
		case map[interface{}]interface{}:
			fmt.Printf("key: %s, value type is %T, value: %v\n", k, value, value)
			if k == "deploy_list" {
				DeployParse(value)
			}
		default:
			fmt.Printf("key: %s, default value type is %T\n", k, value)
		}
	}

	fmt.Println("~~~~~~~~~~~deploy list~~~~~~~~~~~~~~~~~~~~~~~~~~")
	// fmt.Printf("%#v\n", deployList)

	for i := 0; i < len(deployList); i++ {
		fmt.Printf("%#v\n", deployList[i])
		// exec_mv("./yaml/deployment-helm.yaml", "./yaml/"+deployList[i].Name+"-deployment.yaml")

		filePath := "./yaml/" + deployList[i].Name + "-deployment.yaml"
		searchPattern := ".Values.deploy_list.app_web.name"
		replaceWith := ".Values.deploy_list." + deployList[i].App + ".name"
		exec_sed(filePath, searchPattern, replaceWith)
		// cmd := exec.Command("C:/Program Files/Git/usr/bin/cp.exe", "./yaml/deployment-helm.yaml", "./yaml/"+deployList[i].Name+"-deployment.yaml")

		// // 获取标准输出
		// stdout, err := cmd.StdoutPipe()
		// if err != nil {
		// 	log.Fatalf("Error stdout pipe: %s", err)
		// }
		// defer stdout.Close()

		// // 获取标准错误
		// stderr, err := cmd.StderrPipe()
		// if err != nil {
		// 	log.Fatalf("Error creating stderr pipe: %s", err)
		// }
		// defer stderr.Close()

		// // 启动命令
		// if err := cmd.Start(); err != nil {
		// 	log.Fatalf("Error starting command: %s", err)
		// }

		// // 读取输出
		// outBytes, err := io.ReadAll(stdout)
		// if err != nil {
		// 	log.Fatalf("Error reading stdout: %s", err)
		// }
		// errBytes, err := io.ReadAll(stderr)
		// if err != nil {
		// 	log.Fatalf("Error reading stderr: %s", err)
		// }

		// // 等待命令结束
		// if err := cmd.Wait(); err != nil {
		// 	log.Fatalf("Error waiting for command: %s", err)
		// }
		// fmt.Printf("stdout: %s\nstderr: %s\n", outBytes, errBytes)

	}

}
